{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "385ab6cd",
   "metadata": {},
   "source": [
    "### 环境初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8ad72a49",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 在jupyter notebook里env.render看不到窗口\n",
    "# 写一个helper类，用matplotlib刷新显示图像\n",
    "# 初始化传入env，调用helper的render即可\n",
    "from IPython import display # 导入display模块，用于在Jupyter Notebook中显示图像\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt # 导入matplotlib库，用于绘制图像\n",
    "%matplotlib inline\n",
    "\n",
    "class GymHelper:\n",
    "    def __init__(self, env, figsize = (3, 3)):\n",
    "        self.env = env # 初始化Gym环境\n",
    "        self.figsize = figsize # 初始化绘图窗口大小\n",
    "        \n",
    "        plt.figure(figsize = figsize) # 创建绘图窗口\n",
    "        plt.title(self.env.metadata['name']) # 标题设为环境名\n",
    "        self.img = plt.imshow(env.render()) # 在绘图窗口中显示初始图像\n",
    "    \n",
    "    def render(self, title = None):\n",
    "        image_data = self.env.render() # 获取当前环境图像渲染数据\n",
    "        \n",
    "        self.img.set_data(image_data) # 更新绘图窗口中的图像数据\n",
    "        display.display(plt.gcf()) # 刷新显示\n",
    "        display.clear_output(wait = True) # 有新图片时再清除绘图窗口原有图像\n",
    "        if title: # 如果有标题，就显示标题\n",
    "            plt.title(title)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1dac2a9",
   "metadata": {},
   "source": [
    "### 多智能体环境"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3150d937",
   "metadata": {},
   "source": [
    "执行 pip install pettingzoo==1.23.1 即可安装。\n",
    "\n",
    "https://pettingzoo.farama.org/environments/mpe/simple_spread/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cfbd23e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 加载pettingzoo\n",
    "from pettingzoo.mpe import simple_spread_v3\n",
    "\n",
    "# 创建环境，指定渲染模式为rgb_array\n",
    "env = simple_spread_v3.parallel_env(N = 3, max_cycles = 50, \n",
    "                                    render_mode = 'rgb_array', continuous_actions = True)\n",
    "# 重置环境\n",
    "observations, _ = env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "# 重置步数\n",
    "steps = 0\n",
    "\n",
    "# 开始循环\n",
    "while env.agents:\n",
    "    # 渲染环境，title为当前步数\n",
    "    gym_helper.render(title = str(steps))\n",
    "    # 从动作空间中随机选取动作\n",
    "    actions = {agent: env.action_space(agent).sample() for agent in env.agents}  \n",
    "    # 执行action，获取新的信息\n",
    "    observations, rewards, terminations, truncations, infos = env.step(actions)\n",
    "    # 记录步数\n",
    "    steps += 1\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9c3452df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({'agent_0': array([-0.12203537, -0.15697908, -0.34329745,  0.37129653,  0.5905623 ,\n",
       "         -0.13607581,  0.62283367, -0.6354764 , -0.31667632, -0.38397613,\n",
       "         -0.07715695, -0.41063723,  0.08004795, -1.2190971 ,  0.        ,\n",
       "          0.        ,  0.        ,  0.        ], dtype=float32),\n",
       "  'agent_1': array([ 0.17568643,  0.14516462, -0.4204544 , -0.03934069,  0.66771924,\n",
       "          0.2745614 ,  0.69999063, -0.22483923, -0.23951936,  0.02666109,\n",
       "          0.07715695,  0.41063723,  0.15720491, -0.80845994,  0.        ,\n",
       "          0.        ,  0.        ,  0.        ], dtype=float32),\n",
       "  'agent_2': array([-0.02898435,  0.5555049 , -0.26324952, -0.8478006 ,  0.5105143 ,\n",
       "          1.0830213 ,  0.5427857 ,  0.5836207 , -0.39672425,  0.835121  ,\n",
       "         -0.08004795,  1.2190971 , -0.15720491,  0.80845994,  0.        ,\n",
       "          0.        ,  0.        ,  0.        ], dtype=float32)},\n",
       " defaultdict(int,\n",
       "             {'agent_0': -0.7911246085654455,\n",
       "              'agent_1': -0.7911246085654455,\n",
       "              'agent_2': -0.7911246085654455}),\n",
       " {'agent_0': False, 'agent_1': False, 'agent_2': False},\n",
       " {'agent_0': True, 'agent_1': True, 'agent_2': True})"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "observations, rewards, terminations, truncations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38d61b1a",
   "metadata": {},
   "source": [
    "### MADDPG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f41c24f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "# 演员网络（策略网络）\n",
    "class ActorNetwork(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        super(ActorNetwork, self).__init__()\n",
    "        \n",
    "        # 定义全连接网络\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(state_dim, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 512),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, action_dim)\n",
    "        )\n",
    "        \n",
    "        # 使用Adam优化器\n",
    "        self.optimizer = optim.Adam(self.parameters(), lr=0.0001)  \n",
    "        self.apply(weight_init)  # 初始化模型权重\n",
    "\n",
    "    # 前向传播过程\n",
    "    def forward(self, state):\n",
    "        # 输出动作，通过tanh激活函数，并进行缩放和平移，使其落在[0,1]范围内\n",
    "        action = torch.tanh(self.fc(state)) * 0.5 + 0.5\n",
    "        return action\n",
    "\n",
    "# 评论家网络（价值网络）\n",
    "class CriticNetwork(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim):\n",
    "        super(CriticNetwork, self).__init__()\n",
    "        \n",
    "        # 定义全连接网络\n",
    "        self.fc = nn.Sequential(\n",
    "            nn.Linear(state_dim + action_dim, 512), # 输入维度为状态维度+动作维度\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(512, 512),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        self.q = nn.Linear(512, 1)  # 输出Q值的全连接层\n",
    "\n",
    "        # 使用Adam优化器\n",
    "        self.optimizer = optim.Adam(self.parameters(), lr=0.001, weight_decay=0.001)  \n",
    "        self.apply(weight_init)  # 初始化模型权重\n",
    "\n",
    "    # 前向传播过程，输出Q值\n",
    "    def forward(self, state, action):\n",
    "        x = torch.cat([state, action], dim = 1)\n",
    "        x = self.fc(x)\n",
    "        q = self.q(x)  \n",
    "        return q\n",
    "\n",
    "# 初始化模型权重的函数\n",
    "def weight_init(m):\n",
    "    if isinstance(m, nn.Linear):\n",
    "        nn.init.xavier_normal_(m.weight)\n",
    "        if m.bias is not None:\n",
    "            nn.init.constant_(m.bias, 0.0)\n",
    "    elif isinstance(m, nn.BatchNorm1d):\n",
    "        nn.init.constant_(m.weight, 1.0)\n",
    "        nn.init.constant_(m.bias, 0.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0b465e45",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 经验回放缓冲区\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, max_size, state_dim, action_dim, batch_size):\n",
    "        # 初始化回放缓冲区的大小、批次大小、状态维度、动作维度\n",
    "        self.mem_size = max_size\n",
    "        self.batch_size = batch_size\n",
    "        self.mem_cnt = 0\n",
    "        \n",
    "        self.state_dim = state_dim\n",
    "        self.action_dim = action_dim\n",
    "\n",
    "        # 创建用于存储经验的数组\n",
    "        self.state_memory = np.zeros((self.mem_size, state_dim))  # 存储状态\n",
    "        self.action_memory = np.zeros((self.mem_size, action_dim))  # 存储动作\n",
    "        self.reward_memory = np.zeros((self.mem_size, ))  # 存储奖励\n",
    "        self.next_state_memory = np.zeros((self.mem_size, state_dim))  # 存储下一个状态\n",
    "        self.terminal_memory = np.zeros((self.mem_size, ), dtype=bool)  # 存储终止标志\n",
    "\n",
    "    def store_transition(self, state, action, reward, next_state, done):\n",
    "        # 存储经验转换\n",
    "        mem_idx = self.mem_cnt % self.mem_size\n",
    "\n",
    "        self.state_memory[mem_idx] = state\n",
    "        self.action_memory[mem_idx] = action\n",
    "        self.reward_memory[mem_idx] = reward\n",
    "        self.next_state_memory[mem_idx] = next_state\n",
    "        self.terminal_memory[mem_idx] = done\n",
    "\n",
    "        self.mem_cnt += 1\n",
    "\n",
    "    def sample_buffer(self):\n",
    "        # 从缓冲区中随机采样一个批次的经验转换\n",
    "        mem_len = min(self.mem_size, self.mem_cnt)\n",
    "        batch = np.random.choice(mem_len, self.batch_size, replace=False)\n",
    "\n",
    "        states = self.state_memory[batch]\n",
    "        actions = self.action_memory[batch]\n",
    "        rewards = self.reward_memory[batch]\n",
    "        next_states = self.next_state_memory[batch]\n",
    "        terminals = self.terminal_memory[batch]\n",
    "\n",
    "        return states, actions, rewards, next_states, terminals\n",
    "\n",
    "    def ready(self):\n",
    "        # 判断缓冲区是否已准备好进行采样\n",
    "        return self.mem_cnt >= self.batch_size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6de25274",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class DDPG:\n",
    "    def __init__(self, env, gamma=0.99, tau=0.005, action_noise=0.05, max_size=5000000, batch_size=256):\n",
    "        \n",
    "        # 定义环境的state和action的维度\n",
    "        self.state_dim = env.observation_space(env.agents[0]).shape[0]\n",
    "        self.action_dim = env.action_space(env.agents[0]).shape[0]\n",
    "        \n",
    "        # 初始化DDPG算法的超参数和网络模型\n",
    "        self.gamma = gamma  # 折扣因子\n",
    "        self.tau = tau  # 软更新系数\n",
    "        self.action_noise = action_noise  # 动作噪声幅度\n",
    "        \n",
    "        # agent的id和数量\n",
    "        self.agent_ids = env.agents\n",
    "        self.n_agents = len(env.agents)\n",
    "        \n",
    "        # 判断可用的设备是 CPU 还是 GPU\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        \n",
    "        # 创建actor网络，每个agent都需要创建一个对应的网络\n",
    "        self.actors = [ActorNetwork(\n",
    "            state_dim = self.state_dim, action_dim = self.action_dim\n",
    "        ).to(self.device) for _ in range(self.n_agents)]\n",
    "        # 创建目标actor网络，同样是每个agent一个\n",
    "        self.target_actors = [ActorNetwork(\n",
    "            state_dim = self.state_dim, action_dim = self.action_dim\n",
    "        ).to(self.device) for _ in range(self.n_agents)]\n",
    "        \n",
    "        # 创建critic网络\n",
    "        self.critic = CriticNetwork(state_dim=self.state_dim * self.n_agents,\n",
    "                                  action_dim=self.action_dim * self.n_agents).to(self.device)\n",
    "        # 创建目标critic网络\n",
    "        self.target_critic = CriticNetwork(state_dim=self.state_dim * self.n_agents,\n",
    "                                  action_dim=self.action_dim * self.n_agents).to(self.device)\n",
    "\n",
    "        # 创建回放缓冲区\n",
    "        self.memory = ReplayBuffer(max_size=max_size, state_dim=self.state_dim * self.n_agents,\n",
    "                                  action_dim=self.action_dim * self.n_agents, batch_size=batch_size)\n",
    "        \n",
    "        # 初始化目标网络参数与主网络参数相同\n",
    "        self.update_network_parameters(tau=1.0)\n",
    "\n",
    "    # 更新目标网络参数\n",
    "    def update_network_parameters(self, tau=None):\n",
    "        if tau is None:\n",
    "            tau = self.tau\n",
    "\n",
    "        # 遍历每个target_actor并更新参数\n",
    "        for actor, target_actor in zip(self.actors, self.target_actors):\n",
    "            for actor_params, target_actor_params in zip(actor.parameters(),\n",
    "                                                         target_actor.parameters()):\n",
    "                target_actor_params.data.copy_(tau * actor_params + (1 - tau) * target_actor_params)\n",
    "\n",
    "        # 更新target_critic网络参数\n",
    "        for critic_params, target_critic_params in zip(self.critic.parameters(),\n",
    "                                                       self.target_critic.parameters()):\n",
    "            target_critic_params.data.copy_(tau * critic_params + (1 - tau) * target_critic_params)\n",
    "\n",
    "    def remember(self, state, action, reward, next_state, done):\n",
    "        # 定义存储dict\n",
    "        transitions = {\n",
    "            \"state\": np.array([], dtype=float),\n",
    "            \"action\": np.array([], dtype=float),\n",
    "            \"reward\": np.array([0.0], dtype=float),\n",
    "            \"next_state\": np.array([], dtype=float),\n",
    "            \"done\": np.array([False], dtype=bool),\n",
    "        }\n",
    "        # 遍历agent并对数据进行拼接，reward取和、done取或即可\n",
    "        for agent_id in self.agent_ids:\n",
    "            transitions[\"state\"] = np.hstack((transitions[\"state\"], state[agent_id]))\n",
    "            transitions[\"action\"] = np.hstack((transitions[\"action\"], action[agent_id]))\n",
    "            transitions[\"reward\"] += reward[agent_id]\n",
    "            transitions[\"next_state\"] = np.hstack((transitions[\"next_state\"], next_state[agent_id]))\n",
    "            transitions[\"done\"] = transitions[\"done\"] or done[agent_id]\n",
    "            \n",
    "        # 存储经验转换\n",
    "        self.memory.store_transition(transitions[\"state\"], transitions[\"action\"], transitions[\"reward\"], \n",
    "                                     transitions[\"next_state\"], transitions[\"done\"])\n",
    "\n",
    "    # 根据当前状态选择动作\n",
    "    def choose_action(self, observation, train=True):\n",
    "        actions = {}\n",
    "        with torch.no_grad():\n",
    "            for actor, agent_id in zip(self.actors, observation):\n",
    "                # 将状态转化为tensor并传递给actor生成动作\n",
    "                state = torch.FloatTensor(np.array([observation[agent_id]])).to(self.device)\n",
    "                action = actor(state).squeeze()\n",
    "            \n",
    "                # 训练阶段添加一些噪声提高探索性\n",
    "                if train:\n",
    "                    noise = torch.tensor(np.random.normal(loc=0.0, scale=self.action_noise, size=(action.shape)),\n",
    "                                 dtype=torch.float).to(self.device)\n",
    "                    action = torch.clamp(action + noise, 0, 1)\n",
    "                \n",
    "                # 拼接动作\n",
    "                actions[agent_id] = action.cpu().detach().numpy()\n",
    "        return actions\n",
    "\n",
    "    def learn(self):\n",
    "        # 使用经验回放进行训练\n",
    "        if not self.memory.ready():\n",
    "            return\n",
    "        \n",
    "        # 从回放缓冲区中获取一批样本\n",
    "        states, actions, rewards, next_states, dones = self.memory.sample_buffer()\n",
    "        states = torch.FloatTensor(np.array(states)).to(self.device)\n",
    "        actions = torch.FloatTensor(np.array(actions)).to(self.device)\n",
    "        rewards = torch.FloatTensor(np.array(rewards)).to(self.device)\n",
    "        next_states = torch.FloatTensor(np.array(next_states)).to(self.device)\n",
    "        dones = torch.LongTensor(np.array(dones)).to(self.device)\n",
    "        \n",
    "        # 使用目标演员网络生成下一个状态对应的下一个动作，并计算目标评论家网络对应的 Q 值。\n",
    "        with torch.no_grad():\n",
    "            next_actions = []\n",
    "            # 遍历每个agent对应的actor\n",
    "            for i in range(len(self.agent_ids)):\n",
    "                # 将拼接后的state分段送入各个actor\n",
    "                next_act = self.target_actors[i](next_states[:,self.state_dim * i:self.state_dim * (i + 1)])\n",
    "                next_actions.append(next_act)\n",
    "            # 拼接生成的动作\n",
    "            next_actions = torch.cat(next_actions, dim = 1)\n",
    "            \n",
    "            # 计算对应的Q值评估\n",
    "            q_ = self.target_critic(next_states, next_actions).view(-1)\n",
    "            q_[dones] = 0.0\n",
    "            target = rewards + self.gamma * q_\n",
    "        \n",
    "        # 使用当前评论家网络计算当前状态和动作对应的 Q 值\n",
    "        q = self.critic(states, actions).view(-1)\n",
    "\n",
    "        # 计算评论家网络的损失，并根据损失进行反向传播和优化\n",
    "        critic_loss = F.mse_loss(q, target)\n",
    "        \n",
    "        # 梯度清零、反向传播、更新参数\n",
    "        self.critic.optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic.optimizer.step()\n",
    "        \n",
    "        # 生成当前状态对应的新动作，并计算演员网络的损失\n",
    "        new_actions = []\n",
    "        # 遍历每个agent对应的actor\n",
    "        for i in range(len(self.agent_ids)):\n",
    "            # 将拼接后的state分段送入各个actor\n",
    "            new_act = self.actors[i](states[:,self.state_dim * i:self.state_dim * (i + 1)])\n",
    "            new_actions.append(new_act)\n",
    "        # 拼接生成的动作\n",
    "        new_actions = torch.cat(new_actions, dim = 1)\n",
    "        actor_loss = -torch.mean(self.critic(states, new_actions))\n",
    "        \n",
    "        # 根据演员网络的损失进行反向传播和优化\n",
    "        for actor in self.actors:\n",
    "            actor.optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        for actor in self.actors:\n",
    "            actor.optimizer.step()\n",
    "        \n",
    "        # 更新目标网络的参数\n",
    "        self.update_network_parameters()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e8cca22a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode 0: -143.71244446468666           \n",
      "Episode 2500: -130.24697208500103                     \n",
      "Episode 5000: -57.649252798653706                      \n",
      "Episode 7500: -53.60800079752557                         \n",
      "Episode 10000: -39.88985868067233                         \n",
      "Episode 12500: -83.87877751768816                         \n",
      "Episode 15000: -53.9249588926894                          \n",
      "Episode 17500: -34.87404165703529                         \n",
      "Episode 20000: -43.82977968618274                         \n",
      "Episode 22500: -43.75046749616807                         \n",
      "Episode 25000: -38.164828856752436                        \n",
      "Episode 27500: -58.517672159897955                        \n",
      "Episode 30000: -34.58080501484018                          \n",
      "100%|██████████| 30000/30000 [13:25:23<00:00,  1.42s/it] \n"
     ]
    }
   ],
   "source": [
    "# 导入必要的库\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import numpy as np\n",
    "import sys\n",
    "import time\n",
    "import random\n",
    "import collections\n",
    "from tqdm import * # 用于显示进度条\n",
    "\n",
    "# 定义超参数\n",
    "max_episodes = 30000 # 训练episode数\n",
    "\n",
    "# 环境重置\n",
    "env.reset()\n",
    "\n",
    "# 创建DDPQ对象\n",
    "agent = DDPG(env)\n",
    "# 定义保存每个回合奖励的列表\n",
    "episode_rewards = []\n",
    "\n",
    "# 开始循环，tqdm用于显示进度条并评估任务时间开销\n",
    "for episode in tqdm(range(max_episodes), file=sys.stdout):\n",
    "    # 重置环境并获取初始状态\n",
    "    state, _ = env.reset()\n",
    "    # 当前回合的奖励\n",
    "    episode_reward = 0\n",
    "\n",
    "    # 循环进行每一步操作\n",
    "    while env.agents:\n",
    "        # 根据当前状态选择动作\n",
    "        action = agent.choose_action(state)\n",
    "\n",
    "        # 执行动作，获取新的信息\n",
    "        next_state, reward, terminated, truncated, info = env.step(action)\n",
    "        # 判断是否达到终止状态\n",
    "        done = terminated or truncated\n",
    "\n",
    "        # 将五元组加到经验回放缓冲区\n",
    "        agent.remember(state, action, reward, next_state, done)\n",
    "        # 模型训练\n",
    "        agent.learn()\n",
    "        \n",
    "        # 累计episode_reward\n",
    "        if len(env.agents) > 0:\n",
    "            episode_reward += np.sum([reward[agent_id] for agent_id in env.agents])\n",
    "\n",
    "        # 更新当前状态\n",
    "        state = next_state\n",
    "\n",
    "    # 记录当前回合奖励值\n",
    "    episode_rewards.append(episode_reward)\n",
    "\n",
    "    # 打印中间值\n",
    "    if episode % 2500 == 0:\n",
    "        tqdm.write(\"Episode \" + str(episode) + \": \" + str(episode_reward))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3b2ad1ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 使用Matplotlib绘制奖励值的曲线图\n",
    "plt.plot(episode_rewards[::100])\n",
    "plt.title(\"reward\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c74f97e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 重置环境\n",
    "observations, _ = env.reset()\n",
    "# 创建GymHelper\n",
    "gym_helper = GymHelper(env)\n",
    "# 重置步数\n",
    "steps = 0\n",
    "\n",
    "while env.agents:\n",
    "    # 渲染环境，title为当前步数\n",
    "    gym_helper.render(title = str(steps))\n",
    "    # 找到当前状态下的最优动作\n",
    "    actions = agent.choose_action(observations, False)\n",
    "    # 执行action，获取新的信息\n",
    "    observations, rewards, terminations, truncations, infos = env.step(actions)\n",
    "    # 记录步数\n",
    "    steps += 1\n",
    "\n",
    "# 游戏结束\n",
    "gym_helper.render(title = \"Finished\")\n",
    "# 关闭环境\n",
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
